<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html lang="zh-CN"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><meta http-equiv="Content-Language" content="zh-CN"><link href="stylesheet.css" media="all" rel="stylesheet" type="text/css">
<title>CREATE TABLE</title>
<script> var _hmt = _hmt || []; (function() { var hm = document.createElement("script"); hm.src = "https://hm.baidu.com/hm.js?d286c55b63a3c54a1e43d10d4c203e75"; var s = document.getElementsByTagName("script")[0]; s.parentNode.insertBefore(hm, s); })(); </script>
</head><body class="REFENTRY">
<div>
<table summary="Header navigation table" width="100%" border="0" cellpadding="0" cellspacing="0">
<tr><th colspan="5" align="center" valign="bottom">PostgreSQL 8.2.3 中文文档</th></tr>
<tr><td width="10%" align="left" valign="top"><a href="sql-createsequence.html" accesskey="P">后退</a></td><td width="10%" align="left" valign="top"><a href="sql-createsequence.html">快退</a></td><td width="60%" align="center" valign="bottom"></td><td width="10%" align="right" valign="top"><a href="sql-createtableas.html">快进</a></td><td width="10%" align="right" valign="top"><a href="sql-createtableas.html" accesskey="N">前进</a></td></tr>
</table>
<hr align="LEFT" width="100%"></div>
<h1><a name="SQL-CREATETABLE"></a>CREATE TABLE</h1>
<div class="REFNAMEDIV"><a name="AEN48733"></a><h2>名称</h2>CREATE TABLE&nbsp;--&nbsp;定义一个新表</div>
<a name="AEN48736"></a>
<div class="REFSYNOPSISDIV"><a name="AEN48738"></a><h2>语法</h2>
<pre class="SYNOPSIS">CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE <tt class="REPLACEABLE"><i>table_name</i></tt> ( [
  { <tt class="REPLACEABLE"><i>column_name</i></tt> <tt class="REPLACEABLE"><i>data_type</i></tt> [ DEFAULT <tt class="REPLACEABLE"><i>default_expr</i></tt> ] [ <tt class="REPLACEABLE"><i>column_constraint</i></tt> [ ... ] ]
    | <tt class="REPLACEABLE"><i>table_constraint</i></tt>
    | LIKE <tt class="REPLACEABLE"><i>parent_table</i></tt> [ { INCLUDING | EXCLUDING } { DEFAULTS | CONSTRAINTS } ] ... }
    [, ... ]
] )
[ INHERITS ( <tt class="REPLACEABLE"><i>parent_table</i></tt> [, ... ] ) ]
[ WITH ( <tt class="REPLACEABLE"><i>storage_parameter</i></tt> [= <tt class="REPLACEABLE"><i>value</i></tt>] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE <tt class="REPLACEABLE"><i>tablespace</i></tt> ]

这里的 <tt class="REPLACEABLE"><i>column_constraint</i></tt> 是：

[ CONSTRAINT <tt class="REPLACEABLE"><i>constraint_name</i></tt> ]
{ NOT NULL |
  NULL |
  UNIQUE <tt class="REPLACEABLE"><i>index_parameters</i></tt> |
  PRIMARY KEY <tt class="REPLACEABLE"><i>index_parameters</i></tt> |
  CHECK ( <tt class="REPLACEABLE"><i>expression</i></tt> ) |
  REFERENCES <tt class="REPLACEABLE"><i>reftable</i></tt> [ ( <tt class="REPLACEABLE"><i>refcolumn</i></tt> ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
    [ ON DELETE <tt class="REPLACEABLE"><i>action</i></tt> ] [ ON UPDATE <tt class="REPLACEABLE"><i>action</i></tt> ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

而 <tt class="REPLACEABLE"><i>table_constraint</i></tt> 是：

[ CONSTRAINT <tt class="REPLACEABLE"><i>constraint_name</i></tt> ]
{ UNIQUE ( <tt class="REPLACEABLE"><i>column_name</i></tt> [, ... ] ) <tt class="REPLACEABLE"><i>index_parameters</i></tt> |
  PRIMARY KEY ( <tt class="REPLACEABLE"><i>column_name</i></tt> [, ... ] ) <tt class="REPLACEABLE"><i>index_parameters</i></tt> |
  CHECK ( <tt class="REPLACEABLE"><i>expression</i></tt> ) |
  FOREIGN KEY ( <tt class="REPLACEABLE"><i>column_name</i></tt> [, ... ] ) REFERENCES <tt class="REPLACEABLE"><i>reftable</i></tt> [ ( <tt class="REPLACEABLE"><i>refcolumn</i></tt> [, ... ] ) ]
    [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE <tt class="REPLACEABLE"><i>action</i></tt> ] [ ON UPDATE <tt class="REPLACEABLE"><i>action</i></tt> ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

在 <tt class="LITERAL">UNIQUE</tt> 和 <tt class="LITERAL">PRIMARY KEY</tt> 约束中的 <tt class="REPLACEABLE"><i>index_parameters</i></tt> 是：

[ WITH ( <tt class="REPLACEABLE"><i>storage_parameter</i></tt> [= <tt class="REPLACEABLE"><i>value</i></tt>] [, ... ] ) ]
[ USING INDEX TABLESPACE <tt class="REPLACEABLE"><i>tablespace</i></tt> ]</pre>
</div>
<div class="REFSECT1"><a name="SQL-CREATETABLE-DESCRIPTION"></a><h2>描述</h2>
<p><tt class="COMMAND">CREATE TABLE</tt> 在当前数据库创建一个新的空白表。该表将由发出此命令的用户所拥有。</p>
<p>如果给出了模式名(比如 <tt class="LITERAL">CREATE TABLE myschema.mytable ...</tt>)，那么在指定的模式中创建表，否则在当前模式中创建。临时表存在于一个特殊的模式里，因此创建临时表的时候不能指定模式名。表名字必需在同一模式中的其它表、序列、索引、视图名字中唯一。</p>
<p><tt class="COMMAND">CREATE TABLE</tt> 还自动创建一个与该表的行对应的复合数据类型。因此，表不能和同模式中的现有数据类型同名。</p>
<p>可选的约束子句声明约束，新行或者更新的行必须满足这些约束才能成功插入或更新。约束是一个 SQL 对象，它以多种方式协助在表上定义有效数值的集合。</p>
<p>定义约束有两种方法：表约束和列约束。列约束是作为一个列定义的一部分定义的。而表约束并不和某个列绑在一起，它可以作用于多个列上。每个列约束也可以写成表约束；如果某个约束只影响一个列，那么列约束只是符号上的简洁方式而已。</p>
</div>
<div class="REFSECT1"><a name="AEN48788"></a><h2>参数</h2>
<div class="VARIABLELIST">
<dl>
<dt><tt class="LITERAL">TEMPORARY</tt> 或 <tt class="LITERAL">TEMP</tt></dt>
<dd><p>创建为临时表。临时表在会话结束或(可选)当前事务的结尾(参阅下面的 <tt class="LITERAL">ON COMMIT</tt>)自动删除。除非用模式修饰的名字引用，否则现有的同名永久表在临时表存在期间，在本会话过程中是不可见的。任何在临时表上创建的索引也都会被自动删除。</p>
<p>可以选择在 <tt class="LITERAL">TEMPORARY</tt> 或 <tt class="LITERAL">TEMP</tt> 前面放上 <tt class="LITERAL">GLOBAL</tt> 或 <tt class="LITERAL">LOCAL</tt> 。不过这对 PostgreSQL 来说没有任何区别，可以参阅<a href="sql-createtable.html#SQL-CREATETABLE-COMPATIBILITY"><i>兼容性</i></a></p>。</dd>
<dt><tt class="REPLACEABLE"><i>table_name</i></tt></dt>
<dd><p>要创建的表的名字(可以用模式修饰)</p></dd>
<dt><tt class="REPLACEABLE"><i>column_name</i></tt></dt>
<dd><p>在新表中要创建的字段名字</p></dd>
<dt><tt class="REPLACEABLE"><i>data_type</i></tt></dt>
<dd><p>该字段的数据类型。它可以包括数组说明符。有关 PostgreSQL 支持的数据类型的更多信息，请参考<a href="datatype.html">章8</a>。</p></dd>
<dt><tt class="LITERAL">DEFAULT <tt class="REPLACEABLE"><i>default_expr</i></tt></tt></dt>
<dd><p><tt class="LITERAL">DEFAULT</tt> 子句给字段指定缺省值。该数值可以是任何不含变量的表达式(不允许使用子查询和对本表中的其它字段的交叉引用)。缺省表达式的数据类型必须和字段类型匹配。</p>
<p>缺省表达式将被用于任何未声明该字段数值的插入操作。如果没有指定缺省值则缺省值为 NULL 。</p></dd>
<dt><tt class="LITERAL">INHERITS ( <tt class="REPLACEABLE"><i>parent_table</i></tt> [, ... ] )</tt></dt>
<dd><p>可选的 <tt class="LITERAL">INHERITS</tt> 子句声明一系列的表，这个新表自动从这一系列表中继承所有字段。</p>
<p>使用 <tt class="LITERAL">INHERITS</tt> 将在子表和其父表之间创建一个永久的关系，对父表结构的修改通常也会传播到子表。缺省时，扫描父表的时候也会扫描子表。</p>
<p>如果在多个父表中存在同名字段，那么就会报告一个错误，除非这些字段的数据类型在每个父表里都是匹配的。如果没有冲突，那么重复的字段在新表中融合成一个字段。如果列出的新表字段名和继承字段同名，那么它的数据类型也必须和继承字段匹配，并且这些字段定义会融合成一个。不过，新字段可以声明不同于同名继承字段的约束：所有继承过来的约束以及新声明的约束都融合到一起，并且同时作用于新表。如果新表为该字段明确声明了缺省值，那么此缺省值将覆盖任何继承字段的缺省值。否则，该字段的所有父字段缺省值都必须相同，否则就会报错。</p></dd>
<dt><tt class="LITERAL">LIKE <tt class="REPLACEABLE"><i>parent_table</i></tt> [ { INCLUDING | EXCLUDING } { DEFAULTS | CONSTRAINTS } ]</tt></dt>
<dd><p><tt class="LITERAL">LIKE</tt> 子句声明一个表，新表自动从这个表里面继承所有字段名及其数据类型和非空约束。</p>
<p>和 <tt class="LITERAL">INHERITS</tt> 不同，新表与原来的表之间在创建动作完毕之后是完全无关的。在源表做的任何修改都不会传播到新表中，并且也不可能在扫描源表的时候包含新表的数据。</p>
<p>字段缺省表达式只有在声明了 <tt class="LITERAL">INCLUDING DEFAULTS</tt> 之后才会包含进来。缺省是不包含缺省表达式的，结果是新表中所有字段的缺省值都是 NULL 。</p>
<p>非空约束将总是复制到新表中，<tt class="LITERAL">CHECK</tt> 约束则仅在指定了 <tt class="LITERAL">INCLUDING CONSTRAINTS</tt> 的时候才复制，而其他类型的约束则永远也不会被复制。此规则同时适用于表约束和列约束。</p>
<p>和 <tt class="LITERAL">INHERITS</tt> 不同，被复制的列和约束并不使用相同的名字进行融合。如果明确的指定了相同的名字或者在另外一个 <tt class="LITERAL">LIKE</tt> 子句中，那么将会报错。</p></dd>
<dt><tt class="LITERAL">CONSTRAINT <tt class="REPLACEABLE"><i>constraint_name</i></tt></tt></dt>
<dd><p>可选的列约束或表约束的名字。如果约束本身是非法的，那么其名字将会出现在错误信息中，因此像 <tt class="LITERAL">col must be positive</tt> 这样的名字可以表达有用的约束信息。如果约束名中含有空格则必须用双引号界定。如果没有指定约束名，那么系统将会自动生成一个名字。</p></dd>
<dt><tt class="LITERAL">NOT NULL</tt></dt>
<dd><p>字段不允许包含 NULL 值</p></dd>
<dt><tt class="LITERAL">NULL</tt></dt>
<dd><p>字段允许包含 NULL 值，这是缺省。</p>
<p>这个子句的存在只是为和那些非标准 SQL 数据库兼容。不建议在新应用中使用它。</p></dd>
<dt><tt class="LITERAL">UNIQUE</tt> (column constraint)<br><tt class="LITERAL">UNIQUE ( <tt class="REPLACEABLE"><i>column_name</i></tt> [, ... ] )</tt> (table constraint)</dt>
<dd><p><tt class="LITERAL">UNIQUE</tt> 约束表示表里的一个或多个字段的组合必须在全表范围内唯一。唯一约束的行为和列约束一样，只不过多了跨多行的能力。</p>
<p>对于唯一约束而言，NULL 被认为是互不相等的。</p>
<p>每个唯一约束都必须给其使用的字段集合赋予一个与其它唯一约束都不同的名字，并且也不能和主键约束的名字相同，否则就被认为是同样的约束写了两次。</p></dd>
<dt><tt class="LITERAL">PRIMARY KEY</tt> (column constraint)<br><tt class="LITERAL">PRIMARY KEY ( <tt class="REPLACEABLE"><i>column_name</i></tt> [, ... ] )</tt> (table constraint)</dt>
<dd><p>主键约束表明表中的一个或者一些字段只能包含唯一(不重复)的非 NULL 值。从技术上讲，<tt class="LITERAL">PRIMARY KEY</tt> 只是 <tt class="LITERAL">UNIQUE</tt> 和 <tt class="LITERAL">NOT NULL</tt> 的组合，不过把一套字段标识为主键同时也体现了模式设计的元数据，因为主键意味着可以拿这套字段用做行的唯一标识。</p>
<p>一个表只能声明一个主键，不管是作为字段约束还是表约束。</p>
<p>主键约束使用的字段集合应该与其它唯一约束都不同。</p></dd>
<dt><tt class="LITERAL">CHECK ( <tt class="REPLACEABLE"><i>expression</i></tt> )</tt></dt>
<dd><p><tt class="LITERAL">CHECK</tt> 约束声明一个生成布尔结果的表达式，每次将要插入的新行或者将要被更新的行的新值必须使表达式结果为真或未知才能成功，否则会抛出一个异常并且不会修改数据库。声明为字段约束的检查约束应该只引用该字段的数值，而在表约束里出现的表达式可以引用多个字段。</p>
<p>目前，<tt class="LITERAL">CHECK</tt> 表达式不能包含子查询也不能引用除当前行字段之外的变量。</p></dd>
<dt><tt class="LITERAL">REFERENCES <tt class="REPLACEABLE"><i>reftable</i></tt> [ ( <tt class="REPLACEABLE"><i>refcolumn</i></tt> ) ] [ MATCH <tt class="REPLACEABLE"><i>matchtype</i></tt> ] [ ON DELETE <tt class="REPLACEABLE"><i>action</i></tt> ] [ ON UPDATE <tt class="REPLACEABLE"><i>action</i></tt> ]</tt> (column constraint)<br><tt class="LITERAL">FOREIGN KEY ( <tt class="REPLACEABLE"><i>column</i></tt> [, ... ] ) REFERENCES <tt class="REPLACEABLE"><i>reftable</i></tt> [ ( <tt class="REPLACEABLE"><i>refcolumn</i></tt> [, ... ] ) ] [ MATCH <tt class="REPLACEABLE"><i>matchtype</i></tt> ] [ ON DELETE <tt class="REPLACEABLE"><i>action</i></tt> ] [ ON UPDATE <tt class="REPLACEABLE"><i>action</i></tt> ]</tt> (table constraint)</dt>
<dd><p>这些子句声明一个外键约束，外键约束要求新表中一列或多列组成的组应该只包含/匹配被参考的表中对应字段中的值。如果省略 <tt class="REPLACEABLE"><i>refcolumn</i></tt> ，则使用 <tt class="REPLACEABLE"><i>reftable</i></tt> 的主键。被参考字段必须是被参考表中的唯一字段或者主键。请注意，不能在临时表和永久表之间定义外键约束。</p>
<p>向参考字段插入的数值将使用给出的匹配类型与被参考表中被参考列的数值进行匹配。有三种匹配类型：<tt class="LITERAL">MATCH FULL</tt>, <tt class="LITERAL">MATCH PARTIAL</tt>, <tt class="LITERAL">MATCH SIMPLE</tt>(缺省)。<tt class="LITERAL">MATCH FULL</tt> 不允许一个多字段外键的字段为 NULL ，除非所有外键字段都为 NULL 。<tt class="LITERAL">MATCH SIMPLE</tt> 允许某些外键字段为 NULL 而外键的其它部分不是 NULL 。<tt class="LITERAL">MATCH PARTIAL</tt> 目前尚未实现。</p>
<p>另外，当被参考字段中的数据改变的时候，那么将对本表的字段中的数据执行某种操作。<tt class="LITERAL">ON DELETE</tt> 子句声明当被参考表中的被参考行被删除的时候要执行的操作。类似的，<tt class="LITERAL">ON UPDATE</tt> 子句声明被参考表中被参考字段更新为新值的时候要执行的动作。如果该行被更新，但被参考的字段实际上没有变化，那么就不会有任何动作。除了 <tt class="LITERAL">NO ACTION</tt> 检查之外的其他参考动作都不能推迟，即使该约束声明为可推迟也是如此。下面是每个子句的可能动作：</p>
<div class="VARIABLELIST">
<dl>
<dt><tt class="LITERAL">NO ACTION</tt></dt>
<dd><p>生成一个错误，表明删除或更新将产生一个违反外键约束的动作。如果该约束是可推迟的，并且如果还存在任何引用行，那么这个错误将在检查约束的时候生成。这是缺省动作。</p></dd>
<dt><tt class="LITERAL">RESTRICT</tt></dt>
<dd><p>生成一个表明删除或更新将导致违反外键约束的错误。和 <tt class="LITERAL">NO ACTION</tt> 一样，只是动作不可推迟。</p></dd>
<dt><tt class="LITERAL">CASCADE</tt></dt>
<dd><p>删除任何引用了被删除行的行，或者分别把引用行的字段值更新为被参考字段的新数值。</p></dd>
<dt><tt class="LITERAL">SET NULL</tt></dt>
<dd><p>把引用行设置为 NULL 。</p></dd>
<dt><tt class="LITERAL">SET DEFAULT</tt></dt>
<dd><p>把引用字段设置为它们的缺省值。</p></dd>
</dl>
</div>
<p>如果被参考字段经常更新，那么给外键字段增加一个索引可能是合适的，这样与外键字段相关联的引用动作可以更有效地执行。</p></dd>
<dt><tt class="LITERAL">DEFERRABLE</tt><br><tt class="LITERAL">NOT DEFERRABLE</tt></dt>
<dd><p>这两个关键字设置该约束是否可推迟。一个不可推迟的约束将在每条命令之后马上检查。可推迟约束可以推迟到事务结尾使用 <a href="sql-set-constraints.html"><i>SET CONSTRAINTS</i></a> 命令检查。缺省是 <tt class="LITERAL">NOT DEFERRABLE</tt> 。目前只有外键约束接受这个子句。所有其它约束类型都是不可推迟的。</p></dd>
<dt><tt class="LITERAL">INITIALLY IMMEDIATE</tt><br><tt class="LITERAL">INITIALLY DEFERRED</tt></dt>
<dd><p>如果约束是可推迟的，那么这个子句声明检查约束的缺省时间。如果约束是 <tt class="LITERAL">INITIALLY IMMEDIATE</tt>(缺省)，那么每条语句之后就立即检查它。如果约束是 <tt class="LITERAL">INITIALLY DEFERRED</tt> ，那么只有在事务结尾才检查它。约束检查的时间可以用 <a href="sql-set-constraints.html"><i>SET CONSTRAINTS</i></a> 命令修改。</p></dd>
<dt><tt class="LITERAL">WITH ( <tt class="REPLACEABLE"><i>storage_parameter</i></tt> [= <tt class="REPLACEABLE"><i>value</i></tt>] [, ... ] )</tt></dt>
<dd><p>这个子句为表或指定一个可选的存储参数，参见<a href="sql-createtable.html#SQL-CREATETABLE-STORAGE-PARAMETERS"><i>存储参数</i></a>获取更多信息。用于表的 <tt class="LITERAL">WITH</tt> 子句还可以包含 <tt class="LITERAL">OIDS=TRUE</tt> 或单独的 <tt class="LITERAL">OIDS</tt> 来指定给新表中的每一行都分配一个 OID(对象标识符)，或者 <tt class="LITERAL">OIDS=FALSE</tt> 表示不分配 OID 。如果没有指定 <tt class="LITERAL">OIDS</tt> 默认行为取决于 <a href="runtime-config-compatible.html#GUC-DEFAULT-WITH-OIDS">default_with_oids</a> 配置参数。如果新表是从有 OID 的表继承而来，那么即使明确指定 <tt class="LITERAL">OIDS=FALSE</tt> 也将强制按照 <tt class="LITERAL">OIDS=TRUE</tt> 执行。</p>
<p>如果明确或隐含的指定了 <tt class="LITERAL">OIDS=FALSE</tt> ，新表将不会存储 OID ，也不会为行分配 OID 。这将减小 OID 的开销并因此延缓了 32-bit OID 计数器的循环。因为一旦计数器发生循环之后 OID 将不能被视为唯一，这将大大降低 OID 的实用性。另外，排除了 OID 的表也为每条记录减小了 4 字节的存储空间，从而可以稍微提升一些性能。</p>
<p>可以使用 <a href="sql-altertable.html"><i>ALTER TABLE</i></a> 从已有的表中删除 OID 列。</p></dd>
<dt><tt class="LITERAL">WITH OIDS</tt><br><tt class="LITERAL">WITHOUT OIDS</tt></dt>
<dd><p>这些是被废弃的、分别等价于 <tt class="LITERAL">WITH (OIDS)</tt> 和 <tt class="LITERAL">WITH (OIDS=FALSE)</tt> 的语法。</p></dd>
<dt><tt class="LITERAL">ON COMMIT</tt></dt>
<dd><p>控制临时表在事务块结尾的行为。这三个选项是：</p>
<div class="VARIABLELIST">
<dl>
<dt><tt class="LITERAL">PRESERVE ROWS</tt></dt>
<dd><p>不采取任何特别的动作，这是缺省。</p></dd>
<dt><tt class="LITERAL">DELETE ROWS</tt></dt>
<dd><p>删除临时表中的所有行。本质上是在每次提交事务后自动执行一个 <a href="sql-truncate.html"><i>TRUNCATE</i></a> 命令。</p></dd>
<dt><tt class="LITERAL">DROP</tt></dt>
<dd><p>删除临时表</p></dd>
</dl>
</div></dd>
<dt><tt class="LITERAL">TABLESPACE <tt class="REPLACEABLE"><i>tablespace</i></tt></tt></dt>
<dd><p>指定新表将要在 <tt class="REPLACEABLE"><i>tablespace</i></tt> 表空间内创建。如果没有声明，将使用 <a href="runtime-config-client.html#GUC-DEFAULT-TABLESPACE">default_tablespace</a> ，如果 <tt class="VARNAME">default_tablespace</tt> 为空，那么将使用数据库的缺省表空间。</p></dd>
<dt><tt class="LITERAL">USING INDEX TABLESPACE <tt class="REPLACEABLE"><i>tablespace</i></tt></tt></dt>
<dd><p>这个子句允许选择与一个 <tt class="LITERAL">UNIQUE</tt> 或 <tt class="LITERAL">PRIMARY KEY</tt> 约束相关的索引创建时所在的表空间。如果没有提供这个子句，这个索引将在 <a href="runtime-config-client.html#GUC-DEFAULT-TABLESPACE">default_tablespace</a> 中创建，如果 <tt class="VARNAME">default_tablespace</tt> 为空，那么将使用数据库的缺省表空间。</p></dd>
</dl>
</div>
<div class="REFSECT2"><a name="SQL-CREATETABLE-STORAGE-PARAMETERS"></a><h3>存储参数</h3>
<p><tt class="LITERAL">WITH</tt> 子句可以为表指定<i class="FIRSTTERM">存储参数</i>，并在索引上创建 <tt class="LITERAL">UNIQUE</tt> 或 <tt class="LITERAL">PRIMARY KEY</tt> 约束。用于索引的存储参数在 <a href="sql-createindex.html"><i>CREATE INDEX</i></a> 里面描述。目前唯一一个可以在表上使用的存储参数是：</p>
<div class="VARIABLELIST">
<dl>
<dt><tt class="LITERAL">FILLFACTOR</tt></dt>
<dd><p>一个表的填充因子(fillfactor)是一个介于 10 和 100 之间的百分数。100(完全填充)是默认值。如果指定了较小的填充因子，<tt class="COMMAND">INSERT</tt> 操作仅按照填充因子指定的百分率填充表页。每个页上的剩余空间将用于在该页上更新行，这就使得 <tt class="COMMAND">UPDATE</tt> 有机会在同一页上放置同一条记录的新版本，这比把新版本放置在其它页上更有效。对于一个从不更新的表将填充因子设为 100 是最佳选择，但是对于频繁更新的表，较小的填充因子则更加有效。</p></dd>
</dl>
</div>
</div>
</div>
<div class="REFSECT1"><a name="SQL-CREATETABLE-NOTES"></a><h2>注意</h2>
<p>不建议在新应用中使用 OID ，可能情况下，更好的选择是使用一个 <tt class="LITERAL">SERIAL</tt> 或者其它序列发生器做表的主键。如果一个应用使用了 OID 标识表中的特定行，那么建议在该表的 <tt class="STRUCTFIELD">oid</tt> 字段上创建一个唯一约束，以确保该表的 OID 即使在计数器循环之后也是唯一的。如果你需要一个整个数据库范围的唯一标识，那么就要避免假设 OID 是跨表唯一的，你可以用 <tt class="STRUCTFIELD">tableoid</tt> 和行 OID 的组合来实现这个目的。</p>
<div class="TIP">
<blockquote class="TIP">
<p><b>【提示】</b>对那些没有主键的表，不建议使用 <tt class="LITERAL">OIDS=FALSE</tt> ，因为如果既没有 OID 又没有唯一数据字段，那么就很难标识特定的行。</p>
</blockquote>
</div>
<p>PostgreSQL 自动为每个唯一约束和主键约束创建一个索引以确保其唯一性。因此，不必为主键字段明确的创建索引。参阅 <a href="sql-createindex.html"><i>CREATE INDEX</i></a> 获取更多信息。</p>
<p>唯一约束和主键在目前的实现里是不能继承的。如果把继承和唯一约束组合在一起会导致无法运转。</p>
<p>一个表不能超过 1600 个字段。实际的限制比这个更低，因为还有元组长度限制。</p>
</div>
<div class="REFSECT1"><a name="SQL-CREATETABLE-EXAMPLES"></a><h2>例子</h2>
<p>创建 <tt class="STRUCTNAME">films</tt> 和 <tt class="STRUCTNAME">distributors</tt> 表：</p>
<pre class="PROGRAMLISTING">CREATE TABLE films (
    code        char(5) CONSTRAINT firstkey PRIMARY KEY,
    title       varchar(40) NOT NULL,
    did         integer NOT NULL,
    date_prod   date,
    kind        varchar(10),
    len         interval hour to minute
);</pre>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
     did    integer PRIMARY KEY DEFAULT nextval('serial'),
     name   varchar(40) NOT NULL CHECK (name &lt;&gt; '')
);</pre>
<p>创建一个带有 2 维数组的表：</p>
<pre class="PROGRAMLISTING">CREATE TABLE array_int (
    vector  int[][]
);</pre>
<p>为表 <tt class="LITERAL">films</tt> 定义一个唯一表约束。唯一表约束可以在表的一个或多个字段上定义：</p>
<pre class="PROGRAMLISTING">CREATE TABLE films (
    code        char(5),
    title       varchar(40),
    did         integer,
    date_prod   date,
    kind        varchar(10),
    len         interval hour to minute,
    CONSTRAINT production UNIQUE(date_prod)
);</pre>
<p>定义一个检查列约束：</p>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
    did     integer CHECK (did &gt; 100),
    name    varchar(40)
);</pre>
<p>定义一个检查表约束：</p>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
    did     integer,
    name    varchar(40)
    CONSTRAINT con1 CHECK (did &gt; 100 AND name &lt;&gt; '')
);</pre>
<p>为表 <tt class="STRUCTNAME">films</tt> 定义一个主键表约束。主键表约束可以在一个或多个字段上定义。</p>
<pre class="PROGRAMLISTING">CREATE TABLE films (
    code        char(5),
    title       varchar(40),
    did         integer,
    date_prod   date,
    kind        varchar(10),
    len         interval hour to minute,
    CONSTRAINT code_title PRIMARY KEY(code,title)
);</pre>
<p>为表 <tt class="STRUCTNAME">distributors</tt> 定义一个主键约束。下面两个例子是等效的，第一个例子使用了表约束语法，第二个使用了列约束语法。</p>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
    did     integer,
    name    varchar(40),
    PRIMARY KEY(did)
);</pre>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
    did     integer PRIMARY KEY,
    name    varchar(40)
);</pre>
<p>下面这个例子给字段 <tt class="LITERAL">name</tt> 赋予了一个文本常量缺省值，并且将字段 <tt class="LITERAL">did</tt> 的缺省值安排为通过选择序列对象的下一个值生成。<tt class="LITERAL">modtime</tt> 的缺省值将是该行插入的时间戳。</p>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
    name      varchar(40) DEFAULT 'Luso Films',
    did       integer DEFAULT nextval('distributors_serial'),
    modtime   timestamp DEFAULT current_timestamp
);</pre>
<p>在表 <code class="CLASSNAME">distributors</code> 上定义两个 <tt class="LITERAL">NOT NULL</tt> 列约束，其中之一明确给出了名字：</p>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
    did     integer CONSTRAINT no_null NOT NULL,
    name    varchar(40) NOT NULL
);</pre>
<p>为 <tt class="LITERAL">name</tt> 字段定义一个唯一约束：</p>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
    did     integer,
    name    varchar(40) UNIQUE
);</pre>
<p>上面的和下面这样作为一个表约束声明是一样的：</p>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
    did     integer,
    name    varchar(40),
    UNIQUE(name)
);</pre>
<p>创建同样的表，并为表以及唯一索引指定 70% 率：</p>
<pre class="PROGRAMLISTING">CREATE TABLE distributors (
    did     integer,
    name    varchar(40),
    UNIQUE(name) WITH (fillfactor=70)
)
WITH (fillfactor=70);</pre>
<p>在表空间 <tt class="STRUCTNAME">diskvol1</tt> 里创建 <tt class="STRUCTNAME">cinemas</tt> 表：</p>
<pre class="PROGRAMLISTING">CREATE TABLE cinemas (
        id serial,
        name text,
        location text
) TABLESPACE diskvol1;</pre>
</div>
<div class="REFSECT1"><a name="SQL-CREATETABLE-COMPATIBILITY"></a><h2>兼容性</h2>
<p><tt class="COMMAND">CREATE TABLE</tt> 遵循 SQL 标准，一些例外情况在下面列出。</p>
<div class="REFSECT2"><a name="AEN49136"></a><h3>临时表</h3>
<p>尽管 <tt class="LITERAL">CREATE TEMPORARY TABLE</tt> 的语法和 SQL 标准的类似，但是效果是不同的。在标准里，临时表只是定义一次并且从空内容开始自动存在于任何需要它们的会话中。PostgreSQL 要求每个会话为它们使用的每个临时表发出它们自己的 <tt class="LITERAL">CREATE TEMPORARY TABLE</tt> 命令。这样就允许不同的会话将相同的临时表名字用于不同的目的，而标准的实现方法则把一个临时表名字约束为具有相同的表结构。</p>
<p>标准定义的临时表的行为被广泛地忽略了。PostgreSQL 在这方面上的行为类似于许多其它 SQL 数据库系统。</p>
<p>标准中的全局和局部临时表之间的区别在 PostgreSQL 里不存在，因为这种区别取决于模块的概念，而 PostgreSQL 没有这个概念。出于兼容考虑，PostgreSQL 将接受临时表声明中的 <tt class="LITERAL">GLOBAL</tt> 和 <tt class="LITERAL">LOCAL</tt> 关键字，但是他们没有任何作用。</p>
<p>临时表的 <tt class="LITERAL">ON COMMIT</tt> 子句也类似于 SQL 标准，但是有些区别。如果忽略了 <tt class="LITERAL">ON COMMIT</tt> 子句，SQL 标准声明缺省的行为是 <tt class="LITERAL">ON COMMIT DELETE ROWS</tt> 。但是 PostgreSQL 里的缺省行为是 <tt class="LITERAL">ON COMMIT PRESERVE ROWS</tt> 。在 SQL 标准里不存在 <tt class="LITERAL">ON COMMIT DROP</tt> 选项。</p>
</div>
<div class="REFSECT2"><a name="AEN49157"></a><h3>列检查约束</h3>
<p>SQL 标准说 <tt class="LITERAL">CHECK</tt> 列约束只能引用他们作用的字段；只有 <tt class="LITERAL">CHECK</tt> 表约束才能引用多个字段。PostgreSQL 并不强制这个限制；它把字段和表约束看作相同的东西。</p>
</div>
<div class="REFSECT2"><a name="AEN49163"></a><h3><tt class="LITERAL">NULL</tt> "约束"</h3>
<p><tt class="LITERAL">NULL</tt> "约束"(实际上不是约束)是 PostgreSQL 对 SQL 标准的扩展，包括它是为了和其它一些数据库系统兼容以及为了和 <tt class="LITERAL">NOT NULL</tt> 约束对称。因为它是任何字段的缺省，所以它的出现是没有意义的。</p>
</div>
<div class="REFSECT2"><a name="AEN49172"></a><h3>继承</h3>
<p>通过 <tt class="LITERAL">INHERITS</tt> 子句的多重继承是 PostgreSQL 语言的扩展。SQL:1999 及以后的标准使用不同的语法和语义定义了单继承。SQL:1999风格的继承还没有在 PostgreSQL 中实现。</p>
</div>
<div class="REFSECT2"><a name="AEN49178"></a><h3>零字段表</h3>
<p>PostgreSQL 允许创建没有字段的表(比如 <tt class="LITERAL">CREATE TABLE foo();</tt>)。这是对 SQL 标准的扩展，标准不允许存在零字段表。零字段表本身没什么用，但是禁止他们会给 <tt class="COMMAND">ALTER TABLE DROP COLUMN</tt> 带来很奇怪的情况，所以，这个时候忽视标准的限制概念非常清楚。</p>
</div>
<div class="REFSECT2"><a name="AEN49184"></a><h3><tt class="LITERAL">WITH</tt> 子句</h3>
<p><tt class="LITERAL">WITH</tt> 子句是 PostgreSQL 的扩展，同样，存储参数和 OID 也是扩展。</p>
</div>
<div class="REFSECT2"><a name="AEN49190"></a><h3>表空间</h3>
<p>PostgreSQL 的表空间概念不是标准的东西。因此 <tt class="LITERAL">TABLESPACE</tt> 和 <tt class="LITERAL">USING INDEX TABLESPACE</tt> 都是扩展。</p>
</div>
</div>
<div class="REFSECT1"><a name="AEN49196"></a><h2>又见</h2><a href="sql-altertable.html"><i>ALTER TABLE</i></a>, <a href="sql-droptable.html"><i>DROP TABLE</i></a>, <a href="sql-createtablespace.html"><i>CREATE TABLESPACE</i></a></div>
<div>
<hr align="LEFT" width="100%">
<table summary="Footer navigation table" width="100%" border="0" cellpadding="0" cellspacing="0">
<tr><td width="33%" align="left" valign="top"><a href="sql-createsequence.html" accesskey="P">后退</a></td><td width="34%" align="center" valign="top"><a href="index.html" accesskey="H">首页</a></td><td width="33%" align="right" valign="top"><a href="sql-createtableas.html" accesskey="N">前进</a></td></tr>
<tr><td width="33%" align="left" valign="top">CREATE SEQUENCE</td><td width="34%" align="center" valign="top"><a href="sql-commands.html" accesskey="U">上一级</a></td><td width="33%" align="right" valign="top">CREATE TABLE AS</td></tr>
</table>
</div>
</body></html>